home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / info-service / www / src / midaswww-1.0 / midasingot.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-16  |  14.2 KB  |  532 lines
  1. #include <Mrm/MrmAppl.h>                        /* Motif Toolkit and MRM */
  2. #include "midaslist.h"     
  3. #include "midasoperand.h"
  4. #include "midaswidget.h"
  5. #include "midasshell.h"
  6. #include <string.h>
  7.  
  8. MidasOperand MidasConvertFromInteger();
  9. MidasOperand MidasConvertFromString();
  10. MidasOperand MidasConvertFromBoolean();
  11. MidasWidget *MidasWidgetToMW();
  12. MidasShell  *MidasGetShell();
  13. char *MidasGetWidgetName();
  14. char *MidasConvertToString();
  15.  
  16. static char *Option = "ExecuteWhenCreated";
  17.  
  18. typedef struct _IR {char *Command; Boolean ExecuteWhenCreated; } IngotParm;
  19.  
  20. #define Offset(field) XtOffsetOf(IngotParm,field)
  21.  
  22. static XtResource resources[] = {
  23.       {"midasIngots","MidasIngots",XtRString ,sizeof(char *) ,Offset(Command)           ,XtRImmediate,(XtPointer)0},
  24.       {"midasIngots","MidasIngots",XtRBoolean,sizeof(Boolean),Offset(ExecuteWhenCreated),XtRImmediate,(XtPointer)True}};
  25.  
  26. #undef Offset
  27.  
  28. static List *IngotRList;
  29.  
  30. struct Ingot {
  31.    Boolean              Valued;
  32.    MidasOperand         Operand;
  33.    char                *Command;
  34.    Widget               Parent;
  35.    struct Ingot        *ValueOwner;
  36.    List                *CallbackList;
  37.    Boolean              ExecuteWhenCreated;
  38. };          
  39. typedef struct Ingot Ingot;
  40.  
  41.  
  42. static XtConvertArgRec ConvertWidgetArg[] = {{XtBaseOffset,0,sizeof(Widget)}};
  43.  
  44. Ingot *MidasFindIngotHere(w,Name)
  45. Widget w;
  46. char *Name;
  47. {
  48.     MidasWidget *mw = MidasWidgetToMW(w);
  49.     ListItem *i;
  50.     List *TList = mw->IngotList; 
  51.  
  52.     if (TList != NULL)
  53.       {
  54.         i = MidasFindItemInList(TList,Name);
  55.         if (i != 0) return i->Pointer;
  56.       }
  57.     return 0;
  58.  
  59. }
  60. Ingot *MidasFindIngot(w,Name)
  61. Widget w;
  62. char *Name;
  63. {
  64.     MidasShell *ms = MidasGetShell(w);
  65.  
  66.     for (;; w = XtParent(w))
  67.       {
  68.         Ingot *T = MidasFindIngotHere(w,Name);
  69.         if (T != 0) return T;
  70.         if (w == ms->Widget) break; 
  71.       }      
  72.     return 0;
  73. }
  74. static void MidasDestroyIngot(T)
  75. Ingot *T;
  76. /*
  77.     This routine is called from MidasDestroyIngots during the destruction of
  78.     a widget that has ingots. It assumes that all child widgets are also being 
  79.     destroyed and therefore does not worry about them.
  80. */
  81. {
  82.     if (!T->Valued) 
  83.       {
  84.         Ingot *ValueOwner = T->ValueOwner;
  85.         List *CallbackList = ValueOwner->CallbackList;
  86.         if (CallbackList != 0) 
  87.           {
  88.             ListItem *item;
  89.             for (item = CallbackList->First; item != 0 ; item = item->Next)
  90.               {
  91.                 if (item->Pointer == T) 
  92.                   {
  93.                    item->Pointer = 0; 
  94.                    MidasRemoveItemFromList(CallbackList,item);
  95.                    break;
  96.                   }
  97.               }
  98.           } 
  99.       }
  100.     else if (T->Operand.Dynamic) XtFree((char *)T->Operand.Value.P);
  101.     if (T->CallbackList != 0) MidasDestroyList(T->CallbackList);
  102.     XtFree(T->Command);
  103. }
  104. void MidasDestroyIngots(mw)
  105. MidasWidget *mw;
  106. /*
  107.  *  This routine is called whenever a widget that has ingots
  108.  *  goes and gets itself destroyed.
  109.  */
  110. {
  111.     ListItem *item;
  112.     List *TList = mw->IngotList;
  113.  
  114.     for (item = TList->First; item != 0; item = item->Next)
  115.       {
  116.         Ingot *T = item->Pointer;
  117.         MidasDestroyIngot(T);
  118.         item->Pointer = 0;
  119.       } 
  120.     MidasDestroyList(TList);
  121. }
  122. Ingot *MidasCreateIngot(w,Name)
  123. Widget w;
  124. char *Name;
  125. /*
  126.     If this ingot does not already have an explicit ingot of this name it is created.
  127.     A pointer to the (newly created) ingot is returned;
  128.     A created ingot initially has no value and no callbacks;
  129. */
  130. {
  131.     MidasWidget *mw = MidasWidgetToMW(w);
  132.     Ingot *T;
  133.     ListItem *item;
  134.     List *TList = mw->IngotList;
  135.  
  136.     if (TList == NULL) 
  137.       {
  138.         mw->IngotList = TList = MidasCreateEmptyList(XtName(w));
  139.       }
  140.  
  141.     item = MidasFindItemInList(TList,Name);
  142.     if (item == 0)
  143.       {
  144.         T = XtNew(Ingot);
  145.         T->CallbackList = 0;
  146.         T->Command = 0;
  147.         T->Parent = w;
  148.         T->ValueOwner = 0;
  149.         T->Valued = FALSE;
  150.         T->ExecuteWhenCreated = TRUE;
  151.  
  152.         item = MidasAddItemToList(TList,Name);
  153.         item->Pointer = T;
  154.       }
  155.     else T = item->Pointer;
  156.     return T;
  157. }
  158. void MidasInheritIngotValue(T,Name)
  159. Ingot *T;
  160. char *Name;
  161. {
  162.     Ingot *ValueOwner;
  163.     MidasShell *ms = MidasGetShell(T->Parent);
  164.     if (strncmp(Name,"Midas",5) && ms->Widget != T->Parent) 
  165.       ValueOwner = MidasFindIngot(XtParent(T->Parent),Name);
  166.     else ValueOwner = 0;
  167.  
  168.     if (ValueOwner == 0)
  169.       {
  170.         T->Valued = TRUE;
  171.         T->Operand.Value.P   = (XtPointer)"";
  172.         T->Operand.Dynamic = FALSE;
  173.         T->Operand.Type    = MString;
  174.       }
  175.     else 
  176.       {
  177.         if (ValueOwner->Valued == 0) ValueOwner = ValueOwner->ValueOwner;
  178.         T->ValueOwner = ValueOwner; 
  179.       }
  180.  
  181. #ifdef debug
  182.     if (T->Valued) printf("Ingot %s in %s did not ingerit a value\n",Name,XtName(T->Parent));
  183.     else           printf("Ingot %s inherited value %s from %s\n",Name,ValueOwner->Operand.Value,
  184.                                                                   XtName(ValueOwner->Parent));
  185. #endif
  186. }
  187. void MidasSetIngotValue(T,Operand)
  188. Ingot *T;
  189. MidasOperand Operand;
  190. /*
  191.     This routine sets the value of the specified ingot
  192.     and calls the value changed callbacks belonging to the ingot
  193. */
  194. { 
  195.     if (T->Valued && T->Operand.Dynamic) XtFree((char *)T->Operand.Value.P);
  196.     T->Operand = Operand;
  197. /*
  198.  *  BIG KLUGE .. must be fixed soon
  199.  */
  200.     if (strcmp(Operand.Type,MString)==0 && Operand.Dynamic==FALSE)
  201.       {
  202.         T->Operand.Value.P = XtNewString(Operand.Value.P);
  203.         T->Operand.Dynamic = TRUE;
  204.       }
  205.     T->Valued = TRUE;
  206.  
  207.     if (T->Command != 0) MidasDispatchCommandCallback(T->Parent,T->Command,0);
  208.   
  209.     if (T->CallbackList != 0)
  210.       {
  211.         ListItem *item;
  212.         for (item = T->CallbackList->First; item != 0; item = item->Next)
  213.           {
  214.             Ingot *T = item->Pointer;
  215.             MidasDispatchCommandCallback(T->Parent,T->Command,0);
  216.           }
  217.       }
  218. }
  219. void MidasSetCallbackValue(T,Command)
  220. Ingot *T;
  221. char *Command;
  222. {
  223.     Widget SW, w = T->Parent;
  224.     MidasShell *ms = MidasGetShell(w);
  225.  
  226.     if (T->Command == 0)
  227.       {
  228.         if (T->Valued == 0)
  229.           {
  230.             ListItem *item;
  231.             Ingot *ValueOwner = T->ValueOwner;
  232.             if (ValueOwner->CallbackList == 0) ValueOwner->CallbackList = MidasCreateEmptyList("");
  233.             item = MidasAddItemToListPos(ValueOwner->CallbackList,XtName(w),0);
  234.             item->Pointer = T;
  235.           } 
  236.       }   
  237.     else XtFree(T->Command);
  238.     T->Command = XtNewString(Command);
  239. }
  240. MidasOperand MidasGetIngotValue(T)
  241. Ingot *T;
  242. {
  243.    MidasOperand Temp;
  244.    if (T->Valued == 0) T = T->ValueOwner;
  245.    Temp = T->Operand;
  246.    Temp.Dynamic = FALSE; /* The ingot retains ownership of the operand */
  247.    return Temp;
  248. }
  249. char *MidasGetCallbackValue(T)
  250. Ingot *T;
  251. {
  252.    if (T->Command == 0) return XtNewString("");
  253.    else                 return XtNewString(T->Command);
  254. }
  255. MidasOperand MidasGetCallback(w,Name)
  256. Widget w;
  257. char *Name;
  258. {
  259.    MidasOperand Temp;
  260.    Ingot *T = MidasFindIngotHere(w,Name);
  261.    if (T == 0) 
  262.      {
  263.        Temp.Value.P = "";
  264.        Temp.Dynamic = FALSE;
  265.      }
  266.    else 
  267.      {
  268.        Temp.Value.P = MidasGetCallbackValue(T);
  269.        Temp.Dynamic = TRUE;
  270.      }
  271.    Temp.Type = MString;
  272.    return Temp;
  273. }
  274. MidasOperand MidasGetCreateCallback(w)
  275. Widget w;
  276. {
  277.    Ingot *T = MidasFindIngotHere(w,"midasCreateCallback");
  278.    if (T == 0) 
  279.      {
  280.        MidasOperand Temp;
  281.        Temp.Value.P = "";
  282.        Temp.Dynamic = FALSE;
  283.        Temp.Type = MString;
  284.        return Temp;
  285.      } 
  286.    else return MidasGetIngotValue(T);   
  287. }
  288. MidasOperand MidasGetIngot(w,Name)
  289. Widget w;
  290. char *Name;
  291. {
  292.    Ingot *T = MidasFindIngot(w,Name);
  293.    if (T == 0) MidasError("Can not find ingot %s",Name);
  294.    return MidasGetIngotValue(T);   
  295. }
  296. MidasOperand MidasGetValueOwner(w,Name)
  297. Widget w;
  298. char *Name;
  299. {
  300.    MidasOperand Temp;
  301.    Ingot *T = MidasFindIngot(w,Name);
  302.    if (T == 0) MidasError("Can not find ingot %s",Name);
  303.  
  304.    if (T->Valued) Temp.Value.P = (XtPointer) T->Parent;
  305.    else           Temp.Value.P = (XtPointer) T->ValueOwner->Parent;
  306.    Temp.Type = MWidget;
  307.    Temp.Dynamic = FALSE;
  308.  
  309.    return Temp;   
  310. }
  311. MidasOperand MidasGetIngotOption(w,Name)
  312. Widget w;
  313. char *Name;
  314. {
  315.    MidasOperand Temp;
  316.    Ingot *T = MidasFindIngot(w,Name);
  317.    if (T == 0) MidasError("Can not find ingot %s",Name);
  318.  
  319.    Temp.Value.I = T->ExecuteWhenCreated;
  320.    Temp.Type = MBoolean;
  321.    Temp.Dynamic = FALSE;
  322.  
  323.    return Temp;   
  324. }
  325. void MidasSetIngotOption(w,Name,Opt)
  326. Widget w;
  327. char *Name;
  328. Boolean Opt;
  329. {
  330.    MidasOperand Temp;
  331.    Ingot *T = MidasFindIngot(w,Name);
  332.    if (T == 0) MidasError("Can not find ingot %s",Name);
  333.  
  334.    T->ExecuteWhenCreated = Opt;  
  335. }
  336. void MidasSetIngot(w,Name,Temp)
  337. Widget w;
  338. char *Name;
  339. MidasOperand Temp;
  340. {
  341.    Ingot *T = MidasCreateIngot(w, Name);
  342.    MidasSetIngotValue(T, Temp);
  343. #ifdef debug
  344.    printf("Set Ingot %s in %s to value %s\n",Name,XtName(w),Temp.Value.I);
  345. #endif
  346. }
  347. void MidasSetIngotString(w,Name,Value)
  348. Widget w; 
  349. char *Name;
  350. char *Value;
  351. {
  352.    MidasSetIngot(w,Name,MidasConvertFromString(Value));
  353. }
  354. void MidasSetIngotP(w,Name,Temp)
  355. Widget w;
  356. char *Name;
  357. MidasOperand *Temp;
  358. {
  359.    MidasSetIngot(w,Name,*Temp);
  360. }
  361. void MidasSetCallback(w,Name,Command)
  362. Widget w;
  363. char *Name;
  364. char *Command;
  365. {
  366.    Ingot *T = MidasCreateIngot(w, Name);
  367.    MidasInheritIngotValue(T,Name);
  368.    MidasSetCallbackValue(T,Command);
  369. }
  370. void MidasGetIngots(L,w)
  371. List *L;
  372. Widget w;
  373. {
  374.     MidasShell *ms = MidasGetShell(w);
  375.  
  376.     MidasEmptyList(L);
  377.  
  378.     for (;; w = XtParent(w))
  379.       {
  380.         MidasWidget *mw = MidasWidgetToMW(w);
  381.         ListItem *i;
  382.         List *TList = mw->IngotList; 
  383.    
  384.         if (TList != NULL)
  385.           for (i = TList->First; i != 0; i = i->Next)
  386.             if (strncmp(i->Entry,"midas",5))
  387.               if (MidasFindItemInList(L,i->Entry) == 0)
  388.                 MidasAddItemToList(L,i->Entry);
  389.  
  390.         if (w == ms->Widget) break; 
  391.       }
  392. }
  393. static void MidasStoreCallback(w,cname)
  394. Widget w;
  395. char *cname;
  396. {
  397.     char *result;
  398.     char *name = MidasGetWidgetName(w);
  399.     char *value = MidasConvertToString(MidasGetCallback(w,cname));
  400.     char *new = XtMalloc(strlen(name)+strlen(cname)+strlen(Option)+2);
  401.     MidasShell *ms = MidasGetShell(w);
  402.  
  403.     XtGetApplicationResources(w,(XtPointer) &result,resources,1,NULL,0);
  404.     strcpy(new,name);
  405.     strcat(new,".");
  406.     strcat(new,cname);
  407.     XrmPutStringResource(&ms->Database,new,value);
  408.  
  409.     strcat(new,Option);
  410.     value = MidasConvertToString(MidasGetIngotOption(w,cname));
  411.     XrmPutStringResource(&ms->Database,new,value);
  412.  
  413.     ms->Changes++;
  414.  
  415.     XtFree(new);
  416.     XtFree(value);
  417.  
  418.     if (result != 0)
  419.       {
  420.         Boolean found = FALSE;
  421.         char *token, *old = XtNewString(result);
  422.  
  423.         for (token = strtok(old," "); token != NULL; token = strtok(NULL," "))
  424.           if (strcmp(token,cname)==0) found = TRUE;
  425.  
  426.         XtFree(old);
  427.         if (found) { XtFree(name); return; }
  428.         value = XtMalloc(strlen(result)+strlen(cname)+2);
  429.         strcpy(value,result);
  430.         strcat(value," ");
  431.         strcat(value,cname);
  432.       }
  433.     else value = XtNewString(cname);
  434.       
  435.     new = XtMalloc(strlen(name)+strlen(".midasIngots")+1);
  436.     strcpy(new,name);
  437.     strcat(new,".midasIngots");
  438.   
  439.     XrmPutStringResource(&ms->Database,new,value);
  440.  
  441.     XtFree(new);
  442.     XtFree(value);
  443.     XtFree(name);
  444. }
  445. void MidasSetupIngots(mw,IngotNames)
  446. MidasWidget *mw;
  447. char *IngotNames;
  448. {
  449.     List *TList;
  450.     ListItem *item;
  451.     char *Input = XtNewString(IngotNames);
  452.     char *VerbVector[100];
  453.     int VerbCount, i;
  454.     Widget w = mw->Widget;
  455.     MidasShell *ms = MidasGetShell(w);
  456.  
  457.     mw->IngotList = TList = MidasCreateEmptyList(XtName(w));
  458.  
  459.     MidasTokenizeCommand(Input,VerbVector,&VerbCount,XtNumber(VerbVector)," ");
  460. /*
  461.     This could be made more efficient by fetching all the ingots at once
  462. */
  463.     for (i = 0; i < VerbCount; i++)
  464.       {
  465.         IngotParm result;
  466.         Ingot *T = XtNew(Ingot);
  467.         XtResource *temp;
  468.         ListItem *item = MidasFindItemInList(IngotRList,VerbVector[i]);
  469.         if (item == 0)
  470.           {
  471.             temp = (XtResource *) XtMalloc(sizeof(XtResource)*2);
  472.             temp[0] = resources[0];
  473.             temp[1] = resources[1]; 
  474.             temp[0].resource_name = XtNewString(VerbVector[i]);
  475.             temp[1].resource_name = strcpy(XtMalloc(strlen(VerbVector[i])+strlen(Option)+1),VerbVector[i]);
  476.             strcat(temp[1].resource_name,Option);
  477.  
  478.             item = MidasAddItemToList(IngotRList,temp->resource_name);
  479.             item->Pointer = temp;
  480.           }
  481.         else temp = item->Pointer;
  482.      
  483.         XtGetApplicationResources(w,(XtPointer) &result,temp,XtNumber(resources),
  484.                                   NULL,0);
  485.  
  486.         if (result.Command == 0 || *result.Command == '\0') T->Command = 0;
  487.         else T->Command = XtNewString(result.Command);
  488.         T->Valued = 0;
  489.         T->Parent = w;
  490.         T->ValueOwner = 0;
  491.         T->CallbackList = 0;
  492.         T->ExecuteWhenCreated = result.ExecuteWhenCreated;
  493.  
  494.         item = MidasAddItemToList(TList,VerbVector[i]);
  495.         item->Pointer = T;
  496.       }
  497.     XtFree(Input);
  498.  
  499.     for (item = TList->First; item != 0; item = item->Next)
  500.       {
  501.         Widget SW;
  502.         Ingot *T = item->Pointer;
  503.  
  504.         if (T->Valued == 0) MidasInheritIngotValue(T,item->Entry);
  505.         if (T->Command != 0) 
  506.           {
  507.             if (T->Valued == 0)
  508.               {
  509.                 ListItem *item;
  510.                 Ingot *ValueOwner = T->ValueOwner;
  511.                 if (ValueOwner->CallbackList == 0) ValueOwner->CallbackList = MidasCreateEmptyList("");
  512.                 item = MidasAddItemToListPos(ValueOwner->CallbackList,XtName(w),0);
  513.                 item->Pointer = T;
  514.               } 
  515.             if (T->ExecuteWhenCreated) MidasQueueCommand(w,T->Command);
  516.           }
  517.       }
  518. }
  519. void MidasInitializeIngots()
  520. {
  521.     IngotRList = MidasCreateEmptyList("IngotResourceList");
  522.     MidasDeclareFunction("GETINGOT(Widget,name)"           ,MidasGetIngot);
  523.     MidasDeclareFunction("GETCALLBACK(Widget,name)"        ,MidasGetCallback);
  524.     MidasDeclareFunction("GETVALUEOWNER(Widget,name)"      ,MidasGetValueOwner);
  525.     MidasDeclareFunction("GETINGOTOPTION(Widget,name)"     ,MidasGetIngotOption);
  526.     MidasDeclareVerb("SET INGOT Widget *name any..."       ,MidasSetIngotP);   
  527.     MidasDeclareVerb("GET INGOTS list Widget"              ,MidasGetIngots);
  528.     MidasDeclareVerb("SET CALLBACK Widget name name...",    MidasSetCallback);
  529.     MidasDeclareVerb("SET INGOT OPTION Widget name Boolean",MidasSetIngotOption);
  530.     MidasDeclareVerb("STORE CALLBACK Widget name",          MidasStoreCallback);
  531. }
  532.